import type { ValidationError } from '@/types'

export function validateJson(json: string): { isValid: boolean; error: ValidationError | null } {
  try {
    // 空字符串检查
    if (!json.trim()) {
      return { isValid: true, error: null }
    }

    // JSON解析
    const parsed = JSON.parse(json)

    // MCP配置结构验证
    if (typeof parsed === 'object' && parsed !== null) {
      // 检查是否包含mcpServers
      if (parsed.mcpServers && typeof parsed.mcpServers !== 'object') {
        return {
          isValid: false,
          error: {
            type: 'structure',
            message: 'mcpServers必须是一个对象',
          },
        }
      }

      // 验证mcpServers中的每个服务器配置
      if (parsed.mcpServers) {
        for (const [serverName, serverConfig] of Object.entries(parsed.mcpServers)) {
          if (typeof serverConfig !== 'object' || serverConfig === null) {
            return {
              isValid: false,
              error: {
                type: 'structure',
                message: `服务器配置 "${serverName}" 必须是一个对象`,
              },
            }
          }

          const config = serverConfig as any

          // 检查必需的command字段
          if (config.command && typeof config.command !== 'string') {
            return {
              isValid: false,
              error: {
                type: 'structure',
                message: `服务器 "${serverName}" 的 command 字段必须是字符串`,
              },
            }
          }

          // 检查args字段
          if (config.args && !Array.isArray(config.args)) {
            return {
              isValid: false,
              error: {
                type: 'structure',
                message: `服务器 "${serverName}" 的 args 字段必须是数组`,
              },
            }
          }

          // 检查env字段
          if (config.env && typeof config.env !== 'object') {
            return {
              isValid: false,
              error: {
                type: 'structure',
                message: `服务器 "${serverName}" 的 env 字段必须是对象`,
              },
            }
          }
        }
      }
    }

    return { isValid: true, error: null }
  } catch (error) {
    if (error instanceof SyntaxError) {
      // 尝试提取错误位置信息
      const match = error.message.match(/line (\d+) column (\d+)/)
      if (match && match[1] && match[2]) {
        return {
          isValid: false,
          error: {
            type: 'json',
            message: `JSON语法错误: ${error.message}`,
            line: parseInt(match[1]),
            column: parseInt(match[2]),
          },
        }
      }

      return {
        isValid: false,
        error: {
          type: 'json',
          message: `JSON语法错误: ${error.message}`,
        },
      }
    }

    return {
      isValid: false,
      error: {
        type: 'validation',
        message: `验证失败: ${error instanceof Error ? error.message : '未知错误'}`,
      },
    }
  }
}

// 快速JSON格式检查（用于输入时的实时验证）
export function quickJsonCheck(json: string): { canProceed: boolean; reason?: string } {
  const trimmed = json.trim()

  // 空字符串
  if (!trimmed) {
    return { canProceed: false, reason: 'empty' }
  }

  // 检查基本括号匹配
  let braceCount = 0
  let bracketCount = 0
  let inString = false
  let escapeNext = false

  for (let i = 0; i < trimmed.length; i++) {
    const char = trimmed[i]

    if (escapeNext) {
      escapeNext = false
      continue
    }

    if (char === '\\') {
      escapeNext = true
      continue
    }

    if (char === '"') {
      inString = !inString
      continue
    }

    if (inString) continue

    if (char === '{') braceCount++
    else if (char === '}') braceCount--
    else if (char === '[') bracketCount++
    else if (char === ']') bracketCount--
  }

  // 如果括号不匹配，JSON肯定不完整
  if (braceCount !== 0 || bracketCount !== 0) {
    return { canProceed: false, reason: 'unmatched_brackets' }
  }

  // 如果以未闭合的字符串结尾，可能不完整
  if (inString) {
    return { canProceed: false, reason: 'unclosed_string' }
  }

  // 如果以逗号结尾，可能不完整
  if (trimmed.endsWith(',')) {
    return { canProceed: false, reason: 'trailing_comma' }
  }

  // 如果输入过大，给出警告
  if (trimmed.length > 50000) {
    return { canProceed: false, reason: 'too_large' }
  }

  return { canProceed: true }
}

// 验证MCP配置的特定结构
export function validateMcpStructure(parsed: any): {
  isValid: boolean
  error: ValidationError | null
} {
  if (typeof parsed !== 'object' || parsed === null) {
    return {
      isValid: false,
      error: {
        type: 'structure',
        message: 'MCP配置必须是一个对象',
      },
    }
  }

  // 如果有mcpServers字段，验证其结构
  if (parsed.mcpServers) {
    if (typeof parsed.mcpServers !== 'object' || parsed.mcpServers === null) {
      return {
        isValid: false,
        error: {
          type: 'structure',
          message: 'mcpServers必须是一个对象',
        },
      }
    }

    // 检查是否至少有一个服务器配置
    if (Object.keys(parsed.mcpServers).length === 0) {
      return {
        isValid: false,
        error: {
          type: 'structure',
          message: 'mcpServers不能为空',
        },
      }
    }
  }

  return { isValid: true, error: null }
}
